// Go作者版权所有。版权所有。
// 此源代码的使用受BSD样式的约束
// 可以在许可证文件中找到的许可证。

package types

type errorCode int

// 该文件定义了类型检查期间可能产生的错误代码。
// 这些代码共同提供了一个标识符，可用于
// 对某些类型的错误实施特殊处理。
// None
// 不应更改错误代码值：在末尾添加新代码。
// None
// 错误代码应该足够细粒度，以确保错误的确切性质
// 可以很容易地确定，但足够粗糙，它们不是
// 类型检查算法的实现细节。根据经验，
// 如果存在理论重构，则应将错误视为等效错误
// 在类型检查器中，它们正好在一个位置发出。对于
// 例如，类型检查器针对“太多”发出不同的错误消息
// “参数”和“参数太少”，但可以想象另一种类型
// 检查器，该检查只发出一个“错误数量的
// 参数”，因此这些错误应该具有相同的代码。
// None
// 错误代码名称应尽可能简短，同时保持准确性和准确性
// 独特性。在大多数情况下，名字应该以形容词开头
// 描述错误的性质（例如“无效”、“未使用”、“错位”），
// 最后用一个名词来表示相关的语言对象。例如
// “\u DuplicateDecl”或“\u invalidlicexpr”。为简洁起见，命名遵循
// 约定“bad”表示语法有问题，“invalid”表示语法错误
// 类型的问题。

const (
	_ errorCode = iota

	// _测试保留用于仅在自检模式下应用的错误。
	_Test

	// 当包名为“空白标识符”时，发生了ByBrApkkGnMy。
	// None
	// 根据规范：
	// “PACKAGNOName必须不是空白标识符。”
	_BlankPkgName

	// _当文件的包名与文件名不匹配时，会出现不匹配的DpkgName
	// 包名称已由其他文件建立。
	_MismatchedPkgName

	// _当包标识符在外部使用时，会发生InvalidPkgUse
	// 选择器表达式。
	// None
	// 例子：
	// 输入“fmt”
	// None
	// var=fmt
	_InvalidPkgUse

	// _导入路径无效时会出现BadImportPath。
	_BadImportPath

	// _导入包失败时会发生BrokenImport。
	// None
	// 例子：
	// 导入“amissingpackage”
	_BrokenImport

	// _当重命名特殊导入“C”时，将发生import重命名。“C”是一个字母
	// 伪包，并且不能重命名。
	// None
	// 例子：
	// 导入“C”
	_ImportCRenamed

	// _未使用的导入在导入未使用时发生。
	// None
	// 例子：
	// 输入“fmt”
	// None
	// func main（）{}
	_UnusedImport

	// _InvalidInitCycle在检测到无效循环时发生
	// 初始化图。
	// None
	// 例子：
	// var x int=f（）
	// None
	// func f（）int{return x}
	_InvalidInitCycle

	// _多次声明标识符时会发生DuplicateDecl。
	// None
	// 例子：
	// 变量x=1
	// 变量x=2
	_DuplicateDecl

	// _InvalidDeclCycle在声明周期无效时发生。
	// None
	// 例子：
	// 进口“不安全”
	// None
	// T型结构{
	// a[n]int
	// }
	// None
	// var n=unsafe.Sizeof（T{}）
	_InvalidDeclCycle

	// _当类型定义中的循环导致
	// 定义不明确的类型。
	// None
	// 例子：
	// 进口“不安全”
	// None
	// 类型T[unsafe.Sizeof（T{}]int
	_InvalidTypeCycle

	// _当常量声明具有非常量时，会发生InvalidContinit
	// 初始化器。
	// None
	// 例子：
	// var x int
	// 常数=x
	_InvalidConstInit

	// _InvalidConstVal在常量值无法转换为其值时发生
	// 目标类型。
	// None
	// TODO（findleyr）：这个错误代码和示例不是很清楚。考虑
	// 移除它。
	// None
	// 例子：
	// 常数=1<<“您好”
	_InvalidConstVal

	// _InvalidConstType发生在const声明中的基础类型
	// 不是有效的常量类型。
	// None
	// 例子：
	// 常数c*int=4
	_InvalidConstType

	// _当使用预声明（非类型化）值nil来
	// 初始化未声明显式类型的变量。
	// None
	// 例子：
	// var x=零
	_UntypedNil

	// _当右侧的值数为
	// 赋值或初始化表达式的值与数字不匹配
	// 左边的变量的数量。
	// None
	// 例子：
	// 变量x=1，2
	_WrongAssignCount

	// _当赋值的左侧为空时，出现UnassignableOperator
	// 不可转让的。
	// None
	// 例子：
	// func f（）{
	// 常数c=1
	// c=2
	// }
	_UnassignableOperand

	// _当短变量声明（“：=”）未声明
	// 新的变量。
	// None
	// 例子：
	// func f（）{
	// x:=1
	// x:=2
	// }
	_NoNewVar

	// _当赋值操作（+=，*=，等）执行时，会发生MultiClassIgnop
	// 没有单值左侧或右侧。
	// None
	// 根据规范：
	// 在赋值操作中，左侧和右侧表达式列表
	// 必须仅包含一个单值表达式“
	// None
	// 例子：
	// func f（）int{
	// x、 y:=1，2
	// x、 y+=1
	// 返回x+y
	// }
	_MultiValAssignOp

	// _当T类型的值用作
	// 接口，但T未实现预期接口的方法。
	// None
	// 例子：
	// I型接口{
	// f（）
	// }
	// None
	// 类型T int
	// None
	// var x I=T（1）
	_InvalidIfaceAssign

	// _当chan分配无效时，会发生InvalidChanAssign。
	// None
	// 根据规范，在以下情况下，值x可分配给通道类型T：
	// “x为双向通道值，T为通道类型，x为V型和
	// T具有相同的元素类型，并且V或T中至少有一个不是a
	// 已定义类型。“
	// None
	// 例子：
	// 类型T1-chan-int
	// t2chanint型
	// None
	// 变量x T1
	// None
	// var T2=x
	_InvalidChanAssign

	// _当右侧表达式的类型
	// 在赋值中，不能将被赋值变量的类型赋值
	// 分配。
	// None
	// 例子：
	// 变量x[]int
	// var_uint=x
	_IncompatibleAssign

	// _尝试分配给结构字段时发生UnaddressableFieldAssign
	// 在映射值中。
	// None
	// 例子：
	// func f（）{
	// m:=make（映射[字符串]结构{i int}）
	// m[“foo”]。i=42
	// }
	_UnaddressableFieldAssign

	// _当标识符用作类型中的基础类型时，会出现NotAType
	// 声明或类型别名的右侧不表示类型。
	// None
	// 例子：
	// var S=2
	// None
	// T型
	_NotAType

	// _当数组长度不是常量值时，会出现InvalidArrayLen。
	// None
	// 例子：
	// 变量n=3
	// var_u=[n]int{}
	_InvalidArrayLen

	// _当方法名称为“\”时，会出现BlankIfaceMethod。
	// None
	// 根据规范：
	// “每个显式指定的方法的名称必须是唯一的，而不是唯一的
	// 空白。”
	// None
	// 例子：
	// T型接口{
	// _（国际）
	// }
	_BlankIfaceMethod

	// _当映射键类型不支持==和时，会发生不可比较的MapKey
	// != 接线员。
	// None
	// 根据规范：
	// 必须为的操作数完全定义比较运算符==和！=
	// 密钥类型；因此，键类型不能是函数、映射或切片。”
	// None
	// 例子：
	// 变量x映射[T]int
	// None
	// 类型T[]int
	_IncomparableMapKey

	// _当非接口类型嵌入到
	// 界面
	// None
	// 例子：
	// 类型T结构{}
	// None
	// func（T）m（）
	// None
	// I型接口{
	// T
	// }
	_InvalidIfaceEmbed

	// _当嵌入字段的指针形式为*T时，会发生InvalidPtrEmbed，
	// 而T本身就是一个指针，一个不安全的.指针，或者一个接口。
	// None
	// 根据规范：
	// “必须将嵌入字段指定为类型名T或指向的指针
	// 非接口类型名称*T，而T本身可能不是指针类型。“
	// None
	// 例子：
	// 类型T*int
	// None
	// S型结构{
	// *T
	// }
	_InvalidPtrEmbed

	// _当一个方法声明没有确切的方法声明时，就会发生BadRecv
	// 接收器参数。
	// None
	// 例子：
	// func（）uz（）{}
	_BadRecv

	// _当接收器类型表达式的形式不是T时，会发生InvalidRecv
	// 或*T，或T是指针类型。
	// None
	// 例子：
	// 类型T结构{}
	// None
	// func（**T）m（）{}
	_InvalidRecv

	// _当标识符同时显示为字段时，会发生DuplicateFieldAndMethod
	// 和方法名。
	// None
	// 例子：
	// T型结构{
	// 密特
	// }
	// None
	// func（T）m（）{}
	_DuplicateFieldAndMethod

	// _当同一接收器类型上的两个方法具有
	// 同名。
	// None
	// 例子：
	// 类型T结构{}
	// func（T）m（）{}
	// func（T）m（i int）int{return i}
	_DuplicateMethod

	// _当空白标识符用作值或类型时，会发生InvalidBlank。
	// None
	// 根据规范：
	// 空白标识符只能作为操作数出现在左侧
	// 这是一项任务。”
	// None
	// 例子：
	// 变量x=_
	_InvalidBlank

	// _当预先声明的标识符iota在外部使用时发生无效
	// 一个常数的声明。
	// None
	// 例子：
	// var x=物联网
	_InvalidIota

	// _当初始化函数缺少其主体时，将发生MissingInitBody。
	// None
	// 例子：
	// func init（）
	_MissingInitBody

	// _init函数声明参数或
	// 后果
	// None
	// 已弃用：不再由类型检查器发出_无效的decl是
	// 用它来代替。
	_InvalidInitSig

	// _当init声明为除
	// 作用
	// None
	// 例子：
	// var init=1
	// None
	// 例子：
	// func init（）int{return 1}
	_InvalidInitDecl

	// _当main声明为除
	// 函数，在主包中。
	_InvalidMainDecl

	// _当函数返回的值太多时，会出现TooManyValues
	// 在其中使用它的表达式上下文。
	// None
	// 例子：
	// func ReturnTwo（）（int，int）{
	// 返回1，2
	// }
	// None
	// var x=ReturnTwo（）
	_TooManyValues

	// _NotAnExpr在值表达式所在的位置使用类型表达式时发生
	// 这是意料之中的事。
	// None
	// 例子：
	// 类型T结构{}
	// None
	// func f（）{
	// T
	// }
	_NotAnExpr

	// _当浮点常量被截断为整数时，将发生TruncatedFloat
	// 价值
	// None
	// 例子：
	// var_uint=98.6
	_TruncatedFloat

	// _当数值常量溢出其目标类型时，会发生NumericOverflow。
	// None
	// 例子：
	// 变量x int8=1000
	_NumericOverflow

	// _未为所用类型定义运算符时，会发生UndefinedOp
	// 在手术中。
	// None
	// 例子：
	// var c=“a”-“b”
	_UndefinedOp

	// _当二进制中的操作数类型不兼容时，会出现不匹配的类型
	// 活动
	// None
	// 例子：
	// var a=“你好”
	// var b=1
	// var c=a-b
	_MismatchedTypes

	// _当除法运算在编译时可证明时，就会发生DivByZero
	// 时间被零除。
	// None
	// 例子：
	// 常数除数=0
	// var x int=1/除数
	_DivByZero

	// _当使用递增或递减运算符时，会发生NonNumericicDec
	// 应用于非数值。
	// None
	// 例子：
	// func f（）{
	// var c=“c”
	// C++
	// }
	_NonNumericIncDec

	// _将&运算符应用于对象时，会出现UnaddressableOperator
	// 无法寻址的表达式。
	// None
	// 例子：
	// 变量x=&1
	_UnaddressableOperand

	// _当通过间接指向非指针值时，将发生InvalidDirection
	// “*”运算符。
	// None
	// 例子：
	// var x int
	// 变量y=*x
	_InvalidIndirection

	// _对值应用索引操作时，会出现非索引操作数
	// 这是无法索引的。
	// None
	// 例子：
	// 变量x=1
	// 变量y=x[1]
	_NonIndexableOperand

	// _InvalidIndex在索引参数不是整数类型时发生，
	// 消极的，或是出界的。
	// None
	// 例子：
	// var s=[…]int{1,2,3}
	// var x=s[5]
	// None
	// 例子：
	// var s=[]int{1,2,3}
	// var uS=s[-1]
	// None
	// 例子：
	// var s=[]int{1,2,3}
	// 变量i字符串
	// var_uS=s[i]
	_InvalidIndex

	// _当切片表达式中的常量索引
	// 价值正在下降。
	// None
	// 例子：
	// var=[]int{1,2,3}[2:1]
	_SwappedSliceIndices

	// _对值应用切片操作时，会出现非切片操作数
	// 其类型不可切片或不可寻址。
	// None
	// 例子：
	// var x=[…]int{1,2,3}[：1]
	// None
	// 例子：
	// 变量x=1
	// 变量y=1[：1]
	_NonSliceableOperand

	// _当使用三索引切片表达式（a[x:y:z]）时，会发生InvalidSliceExpr
	// 应用于字符串。
	// None
	// 例子：
	// var s=“你好”
	// 变量x=s[1:2:3]
	_InvalidSliceExpr

	// _当换档操作的右侧为空时，发生InvalidShift Count
	// 非整数、负或太大。
	// None
	// 例子：
	// 变量(
	// x字符串
	// y int=1<<x
	// )
	_InvalidShiftCount

	// _当移位操作数不是整数时，发生InvalidShift操作数。
	// None
	// 例子：
	// var s=“你好”
	// var x=s<<2
	_InvalidShiftOperand

	// _InvalidReceive发生在存在从以下值接收的通道时
	// 不是频道，或是仅发送频道。
	// None
	// 例子：
	// func f（）{
	// 变量x=1
	// <-x
	// }
	_InvalidReceive

	// _InvalidSend发生在有一个通道发送到一个非默认值时
	// 信道，或为仅接收信道。
	// None
	// 例子：
	// func f（）{
	// 变量x=1
	// x<-“你好！”
	// }
	_InvalidSend

	// _当索引在切片、数组或数组中重复时，会出现DuplicateLitKey
	// 映射文字。
	// None
	// 例子：
	// var=[]int{0:1，0:2}
	// None
	// 例子：
	// var_u2;=map[string]int{“a”：1，“a”：2}
	_DuplicateLitKey

	// _当映射文字缺少键表达式时，会发生MissingLitKey。
	// None
	// 例子：
	// var{uu=map[string]int{1}
	_MissingLitKey

	// _InvalidLitIndex发生在切片的键值元素中的键或
	// 数组文字不是整数常量。
	// None
	// 例子：
	// 变量i=0
	// var x=[]字符串{i:“世界”}
	_InvalidLitIndex

	// _当数组文字超过其长度时，将发生OverseverArrayIt。
	// None
	// 例子：
	// var_u=[2]int{1,2,3}
	_OversizeArrayLit

	// _MixedStructLit在结构文字包含位置文字的混合时发生
	// 和命名元素。
	// None
	// 例子：
	// var_uz=struct{i，j int}{i:1，2}
	_MixedStructLit

	// _InvalidStructIt在位置结构文字具有不正确的
	// 值的数目。
	// None
	// 例子：
	// var_uz=struct{i，j int}{1,2,3}
	_InvalidStructLit

	// _当结构文字引用的字段
	// 结构类型上不存在。
	// None
	// 例子：
	// var_uz=struct{i int}{j:2}
	_MissingLitField

	// _当结构文本包含重复的
	// 领域。
	// None
	// 例子：
	// var u=结构{i int}{i:1，i:2}
	_DuplicateLitField

	// _当位置结构文本隐式
	// 指定导入类型的未报告字段。
	_UnexportedLitField

	// _当字段名不是有效标识符时，会出现InvalidLitField。
	// None
	// 例子：
	// var_uz=struct{i int}{1:1}
	_InvalidLitField

	// _UntypedLit在复合文字省略所需类型时发生
	// 标识符。
	// None
	// 例子：
	// 类型外部结构{
	// 内部结构{i int}
	// }
	// None
	// var u=外部{内部：{1}
	_UntypedLit

	// _当复合文字表达式与其
	// 类型
	// None
	// 例子：
	// 类型P*struct{
	// x int
	// }
	// var u=P{}
	_InvalidLit

	// _当选择器不明确时，会出现模糊选择器。
	// None
	// 例子：
	// 类型E1结构{i int}
	// 类型E2结构{i int}
	// 类型T结构{E1；E2}
	// None
	// var x T
	// var_uux=x.i
	_AmbiguousSelector

	// _当使用包限定标识符时，会出现UndeclaredImportedName
	// 未经进口包装申报。
	// None
	// 例子：
	// 导入“go/types”
	// None
	// var=types.NotAnActualIdentifier
	_UndeclaredImportedName

	// _当选择器引用未报告的标识符时，会出现未报告的名称
	// 进口包装的包装。
	// None
	// 例子：
	// 导入“反映”
	// None
	// 类型uuReflect.flag
	_UnexportedName

	// _未声明的名称发生在当前文件中未声明标识符时
	// 范围
	// None
	// 例子：
	// var x T
	_UndeclaredName

	// _当选择器引用字段或方法时，会发生MissingFieldOrMethod
	// 这是不存在的。
	// None
	// 例子：
	// 类型T结构{}
	// None
	// var x=T{}.f
	_MissingFieldOrMethod

	// _BaddotSyntax发生在“…”出现在其所在的上下文中时
	// 无效。
	// None
	// 例子：
	// var{uu=map[int][…]int{0:{}
	_BadDotDotDotSyntax

	// _非变量dotdot发生在将“…”用于
	// 一种非变量函数。
	// None
	// 例子：
	// func printArgs（s[]字符串）{
	// 对于u，a:=范围s{
	// println（a）
	// }
	// }
	// None
	// func f（）{
	// s:=[]字符串{“a”、“b”、“c”}
	// 打印参数（s…）
	// }
	_NonVariadicDotDotDot

	// _当“…”用于除
	// 函数声明中的最终参数。
	// None
	// 例子：
	// func f（…int，int）
	_MisplacedDotDotDot

	_ // _已删除InvalidDotOperator。

	// _InvalidDotDot在非可变内置函数中使用“…”时发生
	// 作用
	// None
	// 例子：
	// var s=[]int{1,2,3}
	// var l=长度（s…）
	_InvalidDotDotDot

	// _当内置函数用作
	// 函数值表达式，而不是被调用。
	// None
	// 根据规范：
	// “内置函数没有标准的Go类型，因此只能
	// 出现在呼叫表达式中；它们不能用作函数值。”
	// None
	// 例子：
	// var=复制
	_UncalledBuiltin

	// _InvalidAppend在使用第一个参数调用append时发生，该参数为
	// 一片也没有。
	// None
	// 例子：
	// var uz=append（1,2）
	_InvalidAppend

	// _当cap内置函数的参数不可用时，会发生InvalidCap
	// 支持的类型。
	// None
	// 请参阅https:
	// 支持哪些底层类型作为cap和len的参数。
	// None
	// 例子：
	// var s=2
	// var x=上限
	_InvalidCap

	// _InvalidClose在使用以下参数调用close（…）时发生：
	// 不是信道类型，或是仅接收信道。
	// None
	// 例子：
	// func f（）{
	// var x int
	// 关闭（x）
	// }
	_InvalidClose

	// _当参数不属于切片类型或不属于切片类型时，会发生InvalidCopy
	// 具有兼容类型。
	// None
	// 请参阅https:
	// 有关内置副本的类型要求的信息。
	// None
	// 例子：
	// func f（）{
	// 变量x[]int
	// y:=[]int64{1,2,3}
	// 副本（x，y）
	// }
	_InvalidCopy

	// _InvalidComplex在使用调用复杂内置函数时发生
	// 类型不兼容的参数。
	// None
	// 例子：
	// var=复杂（浮动32（1），浮动64（2））
	_InvalidComplex

	// _InvalidDelete在使用调用delete内置函数时发生
	// 不是映射的第一个参数。
	// None
	// 例子：
	// func f（）{
	// m:=“你好”
	// 删除（m，“e”）
	// }
	_InvalidDelete

	// _当使用
	// 没有复杂类型的参数。
	// None
	// 例子：
	// var=imag（int（1））
	_InvalidImag

	// _当len内置函数的参数不可用时，会发生InvalidLen
	// 支持的类型。
	// None
	// 请参阅https:
	// 支持哪些底层类型作为cap和len的参数。
	// None
	// 例子：
	// var s=2
	// var x=len（s）
	_InvalidLen

	// _当使用三个参数调用make时，会发生SwappedMakeArgs，其
	// 长度参数大于其容量参数。
	// None
	// 例子：
	// var x=制造（[]整数，3，2）
	_SwappedMakeArgs

	// _当使用不支持的类型参数调用make时，会发生InvalidMake。
	// None
	// 请参阅https:
	// 有关可以使用make创建的类型的信息。
	// None
	// 例子：
	// var x=制造（整数）
	_InvalidMake

	// _InvalidReal在使用
	// 没有复杂类型的参数。
	// None
	// 例子：
	// var=实（int（1））
	_InvalidReal

	// _当类型断言应用于
	// 不是接口类型的值。
	// None
	// 例子：
	// 变量x=1
	// var_ux=x（浮动64）
	_InvalidAssert

	// _当类型断言x.（T）的值x
	// 由于缺少或不匹配，接口不能具有动态类型T
	// 方法对T。
	// None
	// 例子：
	// 类型T int
	// None
	// func（t*t）m（）int{return int（*t）}
	// None
	// 类型I接口{m（）int}
	// None
	// 变量x I
	// var=x（T）
	_ImpossibleAssert

	// _当参数类型无法转换为
	// 目标
	// None
	// 请参阅https:
	// 可兑换性。
	// None
	// 例子：
	// 变量x浮动64
	// var u=字符串（x）
	_InvalidConversion

	// _InvalidUntypedConversion发生在没有有效隐式
	// 从满足
	// 使用它的上下文。
	// None
	// 例子：
	// 变量=1+“”
	_InvalidUntypedConversion

	// _BadOffsetofSyntax在使用参数调用不安全的.Offsetof时发生
	// 这不是选择器表达式。
	// None
	// 例子：
	// 进口“不安全”
	// None
	// var x int
	// var=不安全的偏移量（x）
	_BadOffsetofSyntax

	// _当使用方法调用unsafe.Offsetof时，会发生InvalidOffsetof
	// 选择器，而不是字段选择器，或者当字段通过
	// 指针。
	// None
	// 根据规范：
	// None
	// 如果f是一个嵌入字段，那么它必须是无指针可访问的
	// 通过结构的字段进行间接寻址。"
	// None
	// 例子：
	// 进口“不安全”
	// None
	// 类型T结构{f int}
	// 类型S结构{*T}
	// 变量s
	// var=不安全的偏移量（s.f）
	// None
	// 例子：
	// 进口“不安全”
	// None
	// 类型S结构{}
	// None
	// func（S）m（）{}
	// None
	// 变量s
	// var=不安全的偏移量（s.m）
	_InvalidOffsetof

	// _当将无副作用的表达式用作
	// 陈述这种说法没有任何效力。
	// None
	// 例子：
	// func f（i int）{
	// 我，我
	// }
	_UnusedExpr

	// _UnusedVar发生在声明变量但未使用时。
	// None
	// 例子：
	// func f（）{
	// x:=1
	// }
	_UnusedVar

	// _当具有结果的函数缺少返回时，将发生MissingReturn
	// 陈述
	// None
	// 例子：
	// func f（）int{}
	_MissingReturn

	// _当return语句返回不正确的
	// 值的数目。
	// None
	// 例子：
	// func ReturnOne（）int{
	// 返回1，2
	// }
	_WrongResultCount

	// _OutOfScopeResult在由隐式返回的值的名称时发生
	// 空return语句隐藏在嵌套范围中。
	// None
	// 例子：
	// 函数因子（n int）（i int）{
	// 对于i:=2；i<n；i++{
	// 如果n%i==0{
	// 回来
	// }
	// }
	// 返回0
	// }
	_OutOfScopeResult

	// _如果条件不是布尔表达式，则会发生InvalidCond。
	// None
	// 例子：
	// func checkReturn（i int）{
	// 如果我{
	// 恐慌（“非零回报”）
	// }
	// }
	_InvalidCond

	// _InvalidPostDecl在for循环post中有声明时发生
	// 陈述
	// None
	// 例子：
	// func f（）{
	// 对于i:=0；i<10；j:=0{}
	// }
	_InvalidPostDecl

	_ // _已删除InvalidChanRange。

	// _当测距时使用两个迭代变量时，会出现InvalidInterVar
	// 通过一个通道。
	// None
	// 例子：
	// func f（c chan int）{
	// 对于k，v:=范围c{
	// println（k，v）
	// }
	// }
	_InvalidIterVar

	// _当范围表达式的类型不是数组时，会发生InvalidRangeExpr，
	// 切片、字符串、贴图或通道。
	// None
	// 例子：
	// func f（i int）{
	// 对于j:=范围i{
	// println（j）
	// }
	// }
	_InvalidRangeExpr

	// _当break语句不在for、开关中时，就会发生MISPLOCEDBREAK，
	// 或最内层函数定义的select语句。
	// None
	// 例子：
	// func f（）{
	// 打破
	// }
	_MisplacedBreak

	// _当continue语句不在for中时，会发生错位继续
	// 最内层函数定义的循环。
	// None
	// 例子：
	// func sumeven（n int）int{
	// 继续：=func（）{
	// 持续
	// }
	// 总和：=0
	// 对于i:=1；i<=n；i++{
	// 如果我是%2！=0 {
	// 继续
	// }
	// 总和+=i
	// }
	// 回报金额
	// }
	_MisplacedContinue

	// _当故障诊断语句不在
	// 表达式开关。
	// None
	// 例子：
	// func类型名（i接口{}）字符串{
	// 开关i（类型）{
	// 案例int64：
	// 失败
	// 案例int：
	// 返回“int”
	// }
	// 返回“不支持”
	// }
	_MisplacedFallthrough

	// _当类型或表达式开关具有duplicate时，会发生DuplicateCase
	// 案例。
	// None
	// 例子：
	// func printInt（i int）{
	// 开关i{
	// 案例1：
	// println（“一”）
	// 案例1：
	// println（“一”）
	// }
	// }
	_DuplicateCase

	// _当类型或表达式开关具有多个
	// 违约条款。
	// None
	// 例子：
	// func printInt（i int）{
	// 开关i{
	// 案例1：
	// println（“一”）
	// 违约：
	// println（“一”）
	// 违约：
	// println（“1”）
	// }
	// }
	_DuplicateDefault

	// _BadTypeKeyword在.（type）表达式用于其他任何位置时发生
	// 而不是一个类型开关。
	// None
	// 例子：
	// I型接口{
	// m（）
	// }
	// var t I
	// var uut=t（类型）
	_BadTypeKeyword

	// _InvalidTypeSwitch在以下表达式上使用时发生：（type）
	// 不属于接口类型。
	// None
	// 例子：
	// func f（i int）{
	// 开关x:=i.（类型）{}
	// }
	_InvalidTypeSwitch

	// _当开关表达式不可比较时，会发生InvalidXPRSwitch。
	// None
	// 例子：
	// func(){
	// var a结构{ufunc（）}
	// 开关a/*错误无法打开*/{
	// }
	// }
	_InvalidExprSwitch

	// _当选择的案例不是频道发送或接收时，会发生InvalidSelectCase
	// 接收
	// None
	// 例子：
	// func checkChan（c<-chan int）bool{
	// 挑选{
	// 案例c：
	// 返回真值
	// 违约：
	// 返回错误
	// }
	// }
	_InvalidSelectCase

	// _未声明的标签跳转到时发生未声明的标签。
	// None
	// 例子：
	// func f（）{
	// 后藤岛
	// }
	_UndeclaredLabel

	// _重复标签在多次声明标签时发生。
	// None
	// 例子：
	// func f（）int{
	// L:
	// L:
	// 返回1
	// }
	_DuplicateLabel

	// _如果“中断”或“继续”标签不在for上，则会发生错位标签，
	// switch或select语句。
	// None
	// 例子：
	// func f（）{
	// L:
	// a:=[]int{1,2,3}
	// 对于u，e:=范围a{
	// 如果e>10{
	// 打破L
	// }
	// println（a）
	// }
	// }
	_MisplacedLabel

	// _当声明了标签但未使用时，会出现UnusedLabel。
	// None
	// 例子：
	// func f（）{
	// L:
	// }
	_UnusedLabel

	// _JumpOverDecl在标签跳过变量声明时发生。
	// None
	// 例子：
	// func f（）int{
	// 后藤岛
	// x:=2
	// L:
	// x++
	// 返回x
	// }
	_JumpOverDecl

	// _当向前跳转到嵌套对象中的标签时，会发生JumpIntoBlock
	// 块
	// None
	// 例子：
	// func f（x int）{
	// 后藤岛
	// 如果x>0{
	// L:
	// 打印（“内部块”）
	// }
	// }
	_JumpIntoBlock

	// _InvalidMethodExpr在调用指针方法但参数
	// 无法寻址。
	// None
	// 例子：
	// 类型T结构{}
	// None
	// func（*T）m（）int{return 1}
	// None
	// var_uz=T.m（T{}）
	_InvalidMethodExpr

	// _错误argcount发生在传递的参数太少或太多时
	// 函数调用。
	// None
	// 例子：
	// func f（i int）{}
	// var x=f（）
	_WrongArgCount

	// _InvalidCall在调用不属于函数的表达式时发生
	// 类型
	// None
	// 例子：
	// var x=“x”
	// 变量y=x（）
	_InvalidCall

	// _当受限表达式仅用于内置函数时，会出现UnusedResults
	// 通过go或Delay暂停。这样的暂停将丢弃测试结果
	// 这些没有副作用的内置功能，因此是无效的。
	// None
	// 例子：
	// func f（a[]int）int{
	// 推迟会议（a）
	// 返回i
	// }
	_UnusedResults

	// _当延迟表达式不是函数调用时，会发生InvalidDefer，
	// 例如，如果表达式是类型转换。
	// None
	// 例子：
	// func f（i int）int{
	// 第32（i）条
	// 返回i
	// }
	_InvalidDefer

	// _例如，当go表达式不是函数调用时，就会发生InvalidGo
	// 如果表达式是类型转换。
	// None
	// 例子：
	// func f（i int）int{
	// go int32（i）
	// 返回i
	// }
	_InvalidGo

	// 以下所有代码均添加到Go 1.17中。

	// _当声明的语法无效时，会发生BadDecl。
	_BadDecl

	// _当标识符在左侧多次出现时，RepeatedDecl发生
	// 短变量声明的手侧。
	// None
	// 例子：
	// func(){
	// x、 y，y:=1，2，3
	// }
	_RepeatedDecl

	// _InvalidUnsafeAdd在使用
	// 不是整数类型的长度参数。
	// None
	// 例子：
	// 进口“不安全”
	// None
	// var p不安全指针
	// var=不安全。添加（p，float64（1））
	_InvalidUnsafeAdd

	// _InvalidUnsafeSlice在使用
	// 不是指针类型或长度参数的指针参数
	// 这不是整数类型、负值或越界。
	// None
	// 例子：
	// 进口“不安全”
	// None
	// var x int
	// var=不安全的.Slice（x，1）
	// None
	// 例子：
	// 进口“不安全”
	// None
	// var x int
	// var=不安全的.Slice（&x，float64（1））
	// None
	// 例子：
	// 进口“不安全”
	// None
	// var x int
	// var=不安全的.Slice（&x，-1）
	// None
	// 例子：
	// 进口“不安全”
	// None
	// var x int
	// 变量=不安全。切片（&x，uint64（1）<<63）
	_InvalidUnsafeSlice

	// _Todo是尚未确定的错误代码的占位符。
	// TODO（rFindley）在确定泛型代码的错误后删除此错误代码。
	_Todo
)
